// 客户管理路由处理函数
// 该文件包含客户管理相关的所有业务逻辑处理函数

// 引入已初始化的客户模型
const { customers: Customer } = require('../models/init-models')(require('../db').sequelize, require('sequelize').DataTypes);

// 引入xlsx库用于处理Excel文件
const XLSX = require('xlsx');

// 引入文件系统模块
const fs = require('fs');

// 引入工具函数
const { formatPagination, buildLikeQuery, generatePaginationInfo } = require('../utils');

/**
 * 获取客户列表
 * 支持分页和模糊查询
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Promise<void>}
 */
const getCustomerList = async (req, res) => {
    try {
        // 格式化分页参数
        const { page, limit, offset } = formatPagination(req.query);
        
        // 定义可搜索的字段
        const searchableFields = ['customer_name', 'contact_person', 'phone', 'address'];
        
        // 构建模糊查询条件
        const whereConditions = buildLikeQuery(req.query, searchableFields);

        // 构建查询选项
        const queryOptions = {
            limit,    // 每页条数
            offset    // 偏移量
        };

        // 如果有查询条件，则添加到查询选项中
        if (Object.keys(whereConditions).length > 0) {
            queryOptions.where = whereConditions;
        }

        // 使用 findAndCountAll 同时获取数据和总条数
        const result = await Customer.findAndCountAll(queryOptions);

        // 生成分页信息
        const pagination = generatePaginationInfo(result.count, page, limit);

        // 使用统一的分页响应格式返回结果
        res.paginated(result.rows, pagination, '获取客户列表成功');
    } catch (err) {
        // 记录错误日志
        console.error('获取客户列表失败:', err);
        // 返回错误响应
        res.error('获取客户列表失败');
    }
};

/**
 * 通过ID获取单个客户信息
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Promise<void>}
 */
const getCustomerById = async (req, res) => {
    try {
        // 从请求参数中获取客户ID
        const customerId = req.params.id;
        
        // 根据ID查找客户
        const customer = await Customer.findByPk(customerId);

        // 如果客户不存在，返回404错误
        if (!customer) {
            return res.error('客户不存在', 1, 404);
        }

        // 返回客户信息
        res.success(customer, '获取客户信息成功');
    } catch (err) {
        // 记录错误日志
        console.error('获取客户信息失败:', err);
        // 返回错误响应
        res.error('获取客户信息失败');
    }
};

/**
 * 添加客户
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Promise<void>}
 */
const addCustomer = async (req, res) => {
    try {
        // 从请求体中移除 customer_id 字段，让数据库自动生成
        const customerData = { ...req.body };
        delete customerData.customer_id;
        
        // 创建新客户
        const customer = await Customer.create(customerData);
        
        // 返回成功响应
        res.success(customer, '添加客户成功');
    } catch (err) {
        // 记录错误日志
        // 根据错误类型返回不同的错误信息
        if (err.name === 'SequelizeUniqueConstraintError') {
            res.error('客户信息已存在，添加失败', 1, 400);
        } else if (err.name === 'SequelizeValidationError') {
            res.error(`数据验证失败: ${err.message}`, 1, 400);
        } else {
            res.error('添加客户失败');
        }
    }
};

/**
 * 更新客户信息
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Promise<void>}
 */
const updateCustomer = async (req, res) => {
    try {
        // 从请求体或参数中获取客户ID
        const customerId = req.body.customer_id || req.params.id;
        
        // 先查找客户是否存在
        const existingCustomer = await Customer.findByPk(customerId);
        if (!existingCustomer) {
            // 如果客户不存在，返回404错误
            return res.error('客户不存在', 1, 404);
        }

        // 从请求体中移除 customer_id 字段，避免更新主键
        const customerData = { ...req.body };
        delete customerData.customer_id;

        // 更新客户信息
        const [updatedCount] = await Customer.update(customerData, {
            where: {
                customer_id: customerId
            }
        });

        // 重新获取更新后的客户信息
        const updatedCustomer = await Customer.findByPk(customerId);

        // 返回成功响应
        res.success(updatedCustomer, '更新客户成功');
    } catch (err) {
        // 根据错误类型返回不同的错误信息
        if (err.name === 'SequelizeUniqueConstraintError') {
            res.error('客户信息已存在，更新失败', 1, 400);
        } else if (err.name === 'SequelizeValidationError') {
            res.error(`数据验证失败: ${err.message}`, 1, 400);
        } else {
            res.error('更新客户失败');
        }
    }
};

/**
 * 删除客户
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Promise<void>}
 */
const delCustomer = async (req, res) => {
    try {
        // 从请求参数中获取客户ID
        const customerId = req.params.id;
        
        // 删除客户
        const deletedCount = await Customer.destroy({
            where: {
                customer_id: customerId
            }
        });
        
        // 如果没有删除任何记录，说明客户不存在
        if (deletedCount === 0) {
            return res.error('客户不存在', 1, 404);
        }
        
        // 返回成功响应
        res.success({ deletedCount }, '删除客户成功');
    } catch (err) {
        // 返回错误响应
        res.error('删除客户失败');
    }
};

/**
 * 从Excel文件导入客户数据
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Promise<void>}
 */
const importCustomers = async (req, res) => {
    try {
        // 检查是否有上传文件
        if (!req.file) {
            return res.error('请上传Excel文件', 1, 400);
        }

        // 读取上传的Excel文件
        const workbook = XLSX.readFile(req.file.path);
        
        // 获取第一个工作表
        const sheetName = workbook.SheetNames[0];
        const worksheet = workbook.Sheets[sheetName];
        
        // 将工作表转换为JSON数据
        const jsonData = XLSX.utils.sheet_to_json(worksheet);
        
        // 检查是否有数据
        if (!jsonData || jsonData.length === 0) {
            // 删除上传的文件
            fs.unlinkSync(req.file.path);
            return res.error('Excel文件中没有数据', 1, 400);
        }

        // 转换数据格式并验证必填字段
        const customersData = jsonData.map((row, index) => {
            // 检查必填字段
            if (!row['客户名称']) {
                throw new Error(`第${index + 2}行客户名称不能为空`);
            }
            
            if (!row['联系电话']) {
                throw new Error(`第${index + 2}行联系电话不能为空`);
            }
            
            // 转换数据格式
            return {
                customer_name: row['客户名称'],
                phone: row['联系电话'],
                contact_person: row['联系人'] || '',
                address: row['客户地址'] || ''
            };
        });

        // 批量创建客户
        const createdCustomers = await Customer.bulkCreate(customersData, {
            validate: true, // 启用验证
            returning: true // 返回创建的记录
        });

        // 删除上传的文件
        fs.unlinkSync(req.file.path);

        // 返回成功响应
        res.success({
            importedCount: createdCustomers.length,
            customers: createdCustomers
        }, `成功导入${createdCustomers.length}个客户`);
    } catch (err) {
        // 删除上传的文件（如果存在）
        if (req.file && req.file.path && fs.existsSync(req.file.path)) {
            fs.unlinkSync(req.file.path);
        }
        
        // 根据错误类型返回不同的错误信息
        if (err.name === 'SequelizeUniqueConstraintError') {
            res.error(`数据重复：${err.message}`, 1, 400);
        } else if (err.name === 'SequelizeValidationError') {
            res.error(`数据验证失败: ${err.message}`, 1, 400);
        } else {
            res.error(err.message || '导入客户失败');
        }
    }
};

/**
 * 批量操作客户
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Promise<void>}
 */
const batchCustomerOperation = async (req, res) => {
  try {
    const { action, data } = req.body;
    
    switch (action) {
      case 'delete':
        // 批量删除客户
        const deletedCount = await Customer.destroy({
          where: {
            customer_id: {
              [require('sequelize').Op.in]: data.ids
            }
          }
        });
        
        res.success({ deletedCount }, '批量删除客户成功');
        break;
        
      default:
        res.error('不支持的操作类型');
    }
  } catch (err) {
    console.error('批量操作客户失败:', err);
    res.error('批量操作客户失败');
  }
};

// 导出所有路由处理函数
module.exports = {
  getCustomerById,   // 获取单个客户信息
  getCustomerList,   // 获取客户列表
  addCustomer,       // 添加客户
  updateCustomer,    // 更新客户信息
  delCustomer,       // 删除客户
  importCustomers,   // 从Excel导入客户
  batchCustomerOperation // 批量操作客户
};